home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / t_os / wink24 / src / consim.c < prev    next >
Text File  |  1993-07-08  |  11KB  |  516 lines
  1. #include    <stdlib.h>
  2. #include    <ctype.h>
  3. #include    "defs.h"
  4.  
  5. #define DMYKAN  0xFE
  6. #define CRCHR   0x1F
  7. #define TABCHR  0x09
  8.  
  9. extern void colset(UCHAR *vp,int cl,int cnt);
  10. extern void PutChr();
  11. extern void memcpy();
  12. extern void memset();
  13. extern void Dsp_vram();
  14.  
  15.        UCHAR   *cvram=NULL;
  16.        int     MAX_SCR=MAX_Y;
  17.        int     TrmCol=7;
  18.        int     DspCnt=0;
  19. static int     KanMod=TRUE;
  20. static int     BakCh1=0,KanCod=0;
  21. static int     ExtFlg=FALSE;
  22. static void    (*ExtAdr)();
  23. static int     EscCnt=0,Bak_X=0,Bak_Y=0;
  24. static char    EscPrm[8];
  25.  
  26. void    Col_cnv()
  27. {
  28.     int   c;
  29.  
  30.     c = TrmCol & 0x07;
  31.     if ( (TrmCol & 0x18) != 0 )
  32.     c |= 0x10;
  33.     if ( (TrmCol & 0x20) != 0 )
  34.     c |= 0x08;
  35.     TrmCol = c;
  36. }
  37. BOOL    Con_init()
  38. {
  39.     if ( cvram == NULL ) {
  40.     if ( (cvram = (UCHAR *)malloc(MAX_X*MAX_Y*2)) == NULL )
  41.         return ERR;
  42.         colset(cvram,TrmCol,MAX_X*MAX_Y*2);
  43.         Cur_X = Cur_Y = 0;
  44.     } else {
  45.     Cur_X = Bak_X; Cur_Y = Bak_Y;
  46.     }
  47.     Dsp_vram(cvram);
  48.     MAX_SCR = MAX_Y2;
  49.     return FALSE;
  50. }
  51. void    Con_end()
  52. {
  53.     Bak_X = Cur_X; Bak_Y = Cur_Y;
  54.     MAX_SCR = MAX_Y;
  55. }
  56. static void    NextChr(sub)
  57. void     (*sub)();
  58. {
  59.     ExtFlg = TRUE;
  60.     ExtAdr = sub;
  61. }
  62. static void    Scrool()
  63. {
  64.     memcpy(cvram,cvram + (MAX_X * 2),(MAX_X * 2) * (MAX_Y2 - 1));
  65.     colset(cvram + (MAX_X * 2) * (MAX_Y2 - 1),TrmCol,(MAX_X * 2));
  66. /**************
  67.     Disp_Scrool(cvram,TrmCol);
  68. **************/
  69. }
  70. static void    PutBS()
  71. {
  72.     if ( --Cur_X < 0 ) {
  73.         Cur_X = MAX_X - 1;
  74.         if ( --Cur_Y < 0 )
  75.             Cur_Y = 0;
  76.     }
  77. }
  78. static void    PutTAB()
  79. {
  80.     int     i;
  81.     extern void    PutChr();
  82.  
  83.     i = ((Cur_X + TAB) / TAB) * TAB - Cur_X;
  84.  
  85.     if ( DspCnt > 1 && i-- > 0 )
  86.     PutChr(0x20|(TrmCol-2),TABCHR);
  87.     while ( i-- > 0 )
  88.     PutChr(TrmCol,' ');
  89. }
  90. static void    PutLF()
  91. {
  92.     if ( ++Cur_Y >= MAX_Y2 ) {
  93.     Cur_Y = (MAX_Y2 - 1);
  94.     Scrool();
  95.     }
  96. }
  97. static void    PutHOME()
  98. {
  99.     Cur_X = Cur_Y = 0;
  100. }
  101. static void    PutCLS()
  102. {
  103.     colset(cvram,TrmCol,(MAX_X * 2) * MAX_Y2);
  104.     Cur_X = Cur_Y = 0;
  105. }
  106. static void    PutCR()
  107. {
  108.     extern void     PutChr();
  109.  
  110.     if ( DspCnt > 1 )
  111.     PutChr(0x20|(TrmCol-2),CRCHR);
  112.     Cur_X = 0;
  113. }
  114. static void    CurRit()
  115. {
  116.     if ( ++Cur_X >= MAX_X )
  117.         Cur_X = 0;
  118. }
  119. static void    CurLft()
  120. {
  121.     if ( --Cur_X < 0 )
  122.         Cur_X = MAX_X - 1;
  123. }
  124. static void    CurUp()
  125. {
  126.     if ( --Cur_Y < 0 )
  127.         Cur_Y = MAX_Y2 - 1;
  128. }
  129. static void    CurDwn()
  130. {
  131.     if ( ++Cur_Y >= MAX_Y2 )
  132.         Cur_Y = 0;
  133. }
  134. void    SVidAt(ch)
  135. int     ch;
  136. {
  137.     TrmCol = ch & 0x3F;
  138.     Col_cnv();
  139. }
  140. void    SetDC2_s(ch)
  141. int     ch;
  142. {
  143.     Cur_X = BakCh1;
  144.     Cur_Y = ch;
  145.     if ( Cur_X < 0 ) Cur_X = 0;
  146.     if ( Cur_X >= MAX_X ) Cur_X = MAX_X - 1;
  147.     if ( Cur_Y < 0 ) Cur_Y = 0;
  148.     if ( Cur_Y >= MAX_Y2 ) Cur_Y = MAX_Y2 - 1;
  149. }
  150. void    SetDC2(ch)
  151. int     ch;
  152. {
  153.     extern void    SetDC2_s();
  154.  
  155.     BakCh1 = ch;
  156.     NextChr(SetDC2_s);
  157. }
  158. void    SetDC3_s(ch)
  159. int     ch;
  160. {
  161.     extern void    PutChr();
  162.  
  163.     while ( BakCh1-- > 0 )
  164.         PutChr(0x20|TrmCol,ch);
  165. }
  166. void    SetDC3(ch)
  167. int     ch;
  168. {
  169.     extern void    SetDC3_s();
  170.  
  171.     BakCh1 = ch;
  172.     NextChr(SetDC3_s);
  173. }
  174. static void    EraLin()
  175. {
  176.     colset(cvram + (Cur_X * 2) + (MAX_X * 2) * Cur_Y,TrmCol,(MAX_X - Cur_X) * 2);
  177. }
  178. static void    EraScr()
  179. {
  180.     colset(cvram + (Cur_X * 2) + (MAX_X * 2) * Cur_Y,TrmCol,
  181.         (MAX_X * 2) * MAX_Y2 - ((Cur_X * 2) + (MAX_X * 2) * Cur_Y));
  182. }
  183. static void    InsLin()
  184. {
  185.     int     i;
  186.     UCHAR   *p;
  187.  
  188.     p = cvram + (MAX_X * 2) * (MAX_Y2 - 1);
  189.     for ( i = MAX_Y2 - 1 ; i > Cur_Y ; i-- ) {
  190.         memcpy(p,p-(MAX_X * 2),(MAX_X * 2));
  191.         p -= (MAX_X * 2);
  192.     }
  193.     colset(cvram + (MAX_X * 2) * Cur_Y,TrmCol,MAX_X * 2);
  194. }
  195. static void    DelLin()
  196. {
  197.     int     i;
  198.     UCHAR   *p;
  199.  
  200.     p = cvram + (MAX_X * 2) * Cur_Y;
  201.     for ( i = Cur_Y ; i < (MAX_Y2 - 1) ; i ++ ) {
  202.         memcpy(p,p+(MAX_X * 2),(MAX_X * 2));
  203.         p += (MAX_X * 2);
  204.     }
  205.     colset(cvram + (MAX_X * 2) * (MAX_Y2 - 1),TrmCol,MAX_X * 2);
  206. }
  207. void    SCurPs_s(ch)
  208. int     ch;
  209. {
  210.     Cur_Y = BakCh1 - ' ';
  211.     Cur_X = ch - ' ';
  212.     if ( Cur_X < 0 ) Cur_X = 0;
  213.     if ( Cur_X >= MAX_X ) Cur_X = MAX_X - 1;
  214.     if ( Cur_Y < 0 ) Cur_Y = 0;
  215.     if ( Cur_Y >= MAX_Y2 ) Cur_Y = MAX_Y2 - 1;
  216. }
  217. void    SCurPs(ch)
  218. int     ch;
  219. {
  220.     extern void    SCurPs_s();
  221.  
  222.     BakCh1 = ch;
  223.     NextChr(SCurPs_s);
  224. }
  225. void    CurAtt_s()
  226. {
  227. }
  228. void    CurAtt(ch)
  229. int    ch;
  230. {
  231.     extern void    CurAtt_s();
  232.  
  233.     NextChr(CurAtt_s);
  234. }
  235. static void    AnsiH()
  236. {
  237.     if ( EscPrm[0] > 0 ) EscPrm[0]--;
  238.     if ( EscPrm[1] > 0 ) EscPrm[1]--;
  239.     Cur_Y = EscPrm[0];
  240.     Cur_X = EscPrm[1];
  241.     if ( Cur_X < 0 ) Cur_X = 0;
  242.     if ( Cur_X >= MAX_X ) Cur_X = MAX_X - 1;
  243.     if ( Cur_Y < 0 ) Cur_Y = 0;
  244.     if ( Cur_Y >= MAX_Y2 ) Cur_Y = MAX_Y2 - 1;
  245. }
  246. static void    AnsiA()
  247. {
  248.     if ( EscPrm[0] == 0 ) EscPrm[0] = 1;
  249.     if ( (Cur_Y -= EscPrm[0]) < 0 )
  250.         Cur_Y = 0;
  251. }
  252. static void    AnsiB()
  253. {
  254.     if ( EscPrm[0] == 0 ) EscPrm[0] = 1;
  255.     if ( (Cur_Y += EscPrm[0]) >= MAX_Y2 )
  256.         Cur_Y = MAX_Y2 - 1;
  257. }
  258. static void    AnsiC()
  259. {
  260.     if ( EscPrm[0] == 0 ) EscPrm[0] = 1;
  261.     if ( (Cur_X += EscPrm[0]) >= MAX_X )
  262.         Cur_X = MAX_X - 1;
  263. }
  264. static void    AnsiD()
  265. {
  266.     if ( EscPrm[0] == 0 ) EscPrm[0] = 1;
  267.     if ( (Cur_X -= EscPrm[0]) < 0 )
  268.         Cur_X = 0;
  269. }
  270. static void    Ansis()
  271. {
  272.     Bak_X = Cur_X;
  273.     Bak_Y = Cur_Y;
  274. }
  275. static void    Ansiu()
  276. {
  277.     Cur_X = Bak_X;
  278.     Cur_Y = Bak_Y;
  279. }
  280. static void    AnsiJ()
  281. {
  282.     switch(EscPrm[0]) {
  283.         case 0: EraScr(); break;
  284.         case 1: colset(cvram,TrmCol,(Cur_X * 2) + (MAX_X * 2) * Cur_Y); break;
  285.         case 2: PutCLS(); break;
  286.     }
  287. }
  288. static void    AnsiK()
  289. {
  290.     switch(EscPrm[0]) {
  291.         case 0: EraLin(); break;
  292.         case 1:
  293.             if ( Cur_X > 0 )
  294.         colset(cvram + (MAX_X * 2) * Cur_Y,TrmCol,Cur_X * 2);
  295.             break;
  296.         case 2: colset(cvram + (MAX_X * 2) * Cur_Y,TrmCol,MAX_X * 2); break;
  297.     }
  298. }
  299. static void    AnsiM()
  300. {
  301.     if ( EscPrm[0] == 0 ) EscPrm[0] = 1;
  302.     while ( EscPrm[0]-- > 0 )
  303.         DelLin();
  304.     Cur_X = 0;
  305. }
  306. static void    AnsiL()
  307. {
  308.     if ( EscPrm[0] == 0 ) EscPrm[0] = 1;
  309.     while ( EscPrm[0]-- > 0 )
  310.         InsLin();
  311.     Cur_X = 0;
  312. }
  313. static void    Ansim()
  314. {
  315.     int     c=7;
  316.     int     i,n;
  317.     static char ansiatt[]={ 0x00,0x08,0x00,0x00,0x00,0x10,0x00,0x08,0x00 };
  318.     static char ansicol[]={ 0,2,4,6,1,3,5,7 };
  319.  
  320.     for ( n = 0 ; n < EscCnt ; n++ ) {
  321.         if ( (i = EscPrm[n]) >= 1 && i <= 7 ) {
  322.             c |= ansiatt[i];
  323.     } else if ( i == 0 ) {
  324.         c = 7;
  325.         } else if ( i >= 30 && i <= 38 ) {
  326.             c &= 0xF8;
  327.             c |= ansicol[i-30];
  328.         } else if ( i >= 40 && i <= 47 ) {
  329.             c &= 0xF8;
  330.             c |= ansicol[i-40];
  331.             c |= 0x10;
  332.         }
  333.     }
  334.     TrmCol = c;
  335. }
  336. void    AnsiCom(ch)
  337. int     ch;
  338. {
  339.     if ( ch == ';' && EscCnt < 8 )
  340.         EscCnt++;
  341.     else if ( ch >= '0' && ch <= '9' )
  342.         EscPrm[EscCnt] = EscPrm[EscCnt] * 10 + (ch - '0');
  343.     else if ( ch != ' ' ) {
  344.         EscCnt++;
  345.         switch(ch) {
  346.             case 'H': AnsiH(); break;
  347.             case 'f': AnsiH(); break;
  348.             case 'A': AnsiA(); break;
  349.             case 'B': AnsiB(); break;
  350.             case 'C': AnsiC(); break;
  351.             case 'D': AnsiD(); break;
  352.             case 's': Ansis(); break;
  353.             case 'u': Ansiu(); break;
  354.             case 'J': AnsiJ(); break;
  355.             case 'K': AnsiK(); break;
  356.             case 'm': Ansim(); break;
  357.             case 'M': AnsiM(); break;
  358.             case 'L': AnsiL(); break;
  359.         }
  360.         return;
  361.     }
  362.     NextChr(AnsiCom);
  363. }
  364. static void    AnsiESC()
  365. {
  366.     extern void    AnsiCom();
  367.  
  368.     memset(EscPrm,0,8);
  369.     EscCnt = 0;
  370.     NextChr(AnsiCom);
  371. }
  372. static    void    ShtKan(int ch)
  373. {
  374. }
  375. static    void    UnShtKan(int ch)
  376. {
  377. }
  378. void    EscCom(ch)
  379. int     ch;
  380. {
  381.     extern void    SCurPs(),SVidAt(),CurAtt();
  382.  
  383.     switch(ch) {
  384.         case '*': PutCLS(); break;
  385.         case 'T': EraLin(); break;
  386.         case 'Y': EraScr(); break;
  387.         case 'E': InsLin(); break;
  388.         case 'R': DelLin(); break;
  389.         case '=': NextChr(SCurPs); break;
  390.         case 'G': NextChr(SVidAt); break;
  391.         case 'K': KanMod = TRUE; break;
  392.         case 'C': KanMod = FALSE; break;
  393.     case '.': NextChr(CurAtt); break;
  394.         case '[': AnsiESC(); break;
  395.     case '$': NextChr(ShtKan); break;
  396.     case '(': NextChr(UnShtKan); break;
  397.         default: PutChr(TrmCol|0x20,ch); break;
  398.     }
  399. }
  400. static void    PutCnt(ch)
  401. int     ch;
  402. {
  403.     extern void    SetDC2(),SetDC3(),EscCom();
  404.  
  405.     if ( DspCnt != 0 ) {
  406.     switch(ch) {
  407.         case 0x08: PutBS(); break;
  408.             case 0x09: PutTAB(); break;
  409.         case 0x0A: PutLF(); break;
  410.         case 0x0D: PutCR(); break;
  411.         default: 
  412.         if ( DspCnt > 1 )
  413.             PutChr(TrmCol|0x20,ch);
  414.         break;
  415.     }
  416.     return;
  417.     }
  418.     switch(ch) {
  419.         case 0x08: PutBS(); break;
  420.         case 0x09: PutTAB(); break;
  421.     case 0x0A: PutLF(); break;
  422.         case 0x0B: PutHOME(); break;
  423.     case 0x0C: PutCLS(); break;
  424.         case 0x0D: PutCR(); break;
  425.  
  426.     case 0x12: NextChr(SetDC2); break;
  427.         case 0x13: NextChr(SetDC3); break;
  428.         case 0x15: PutCLS(); break;
  429.     case 0x16: PutCLS(); break;
  430.  
  431.     case 0x1B: NextChr(EscCom); break;
  432.  
  433.     case 0x1C: CurRit(); break;
  434.         case 0x1D: CurLft(); break;
  435.         case 0x1E: CurUp(); break;
  436.         case 0x1F: CurDwn(); break;
  437.  
  438.         default:
  439.         if ( DspCnt > 1 )
  440.         PutChr(TrmCol|0x20,ch);
  441.         break;
  442.     }
  443. }
  444. void    PutChr(att,ch)
  445. int     att,ch;
  446. {
  447.     UCHAR   *p;
  448.  
  449.     if ( (att & 0x20) == 0 ) {
  450.     if ( ch < ' ' || ch == 0x7f ) {
  451.         PutCnt(ch);
  452.         return;
  453.     }
  454.     }
  455.  
  456.     if ( ch == '\0' )
  457.     return;
  458.  
  459.     p = cvram + Cur_X * 2 + (MAX_X * 2) * Cur_Y;
  460.     *(p++) = (att & 0xDF); *p = ch;
  461.  
  462.     if ( ++Cur_X >= MAX_X ) {
  463.         Cur_X = 0;
  464.     if ( ++Cur_Y >= MAX_Y2 ) {
  465.             Cur_Y = MAX_Y2 - 1;
  466.             Scrool();
  467.         }
  468.     }
  469. }
  470. void    BakPut(ch)
  471. int     ch;
  472. {
  473.     ch &= 0xff;
  474.  
  475.     if ( ExtFlg != FALSE ) {
  476.     ExtFlg = FALSE;
  477.     (*ExtAdr)(ch);
  478.         return;
  479.     }
  480.  
  481.     if ( KanMod != FALSE ) {
  482.         if ( KanCod != '\0' ) {
  483.             if ( iskanji2(ch) != FALSE ) {
  484.         if ( Cur_X == (MAX_X - 1) ) {
  485.                     PutChr(TrmCol,DMYKAN);
  486.                     PutChr(TrmCol,DMYKAN);
  487.         } else {
  488. #ifdef    TOWNS
  489.             PutChr(0x40|TrmCol,KanCod);
  490.                     PutChr(0x80|TrmCol,ch);
  491. #else
  492.             ch = sjistojis((KanCod << 8) | ch);
  493.             PutChr(0x40|TrmCol,ch >> 8);
  494.                     PutChr(0x80|TrmCol,ch & 0xff);
  495. #endif
  496.                 }
  497.             } else {
  498.         PutChr(TrmCol,KanCod);
  499.         PutChr(TrmCol,ch);
  500.         }
  501.             KanCod = '\0';
  502.         return;
  503.         } else if ( iskanji(ch) != FALSE ) {
  504.         KanCod = ch;
  505.             return;
  506.         }
  507.     }
  508.     PutChr(TrmCol,ch);
  509. }
  510. void    BakStr(str)
  511. char    *str;
  512. {
  513.     while ( *str != '\0' )
  514.     BakPut(*(str++));
  515. }
  516.